home *** CD-ROM | disk | FTP | other *** search
/ Workbench Design / WB Collection.iso / workbench werkzeuge / memory & system tools / tinymeter / source / tinymeter_main / handler.c < prev    next >
C/C++ Source or Header  |  1996-04-07  |  38KB  |  598 lines
  1. #include <intuition/classusr.h>
  2. #include <intuition/gadgetclass.h>
  3. #include <intuition/cghooks.h>
  4. #include <intuition/icclass.h>
  5. #include <intuition/classes.h>
  6. #include <utility/tagitem.h>
  7. #include <exec/types.h>
  8. #include <exec/memory.h>
  9. #include <dos/dos.h>
  10. #include <exec/types.h>
  11. #include <exec/memory.h>
  12. #include <dos/notify.h>
  13. #include <intuition/intuition.h>
  14. #include <libraries/SysInfo.h>
  15. #include <utility/tagitem.h>
  16. #include <clib/macros.h>
  17. #include <libraries/commodities.h>
  18. #include <libraries/ScreenNotify.h>
  19. #include "gaugeclass.h"
  20. #include "tinymeter.h"
  21.  
  22. extern struct Library *RetinaBase;
  23.  
  24. extern ULONG idle;
  25.  
  26. #define test_test       0
  27. #define test_getwin     1
  28.  
  29. #define do_clock        1
  30. #define do_mem          2
  31. #define do_vol          3
  32.  
  33. struct TestMessage
  34. {
  35.     struct  Message ts_Message;
  36.  
  37.     ULONG   MethodID;
  38.  
  39.     struct  tm_sys_set  *set;
  40.     struct  tm_gau_set  *list;
  41.  
  42.     ULONG   posx,
  43.             posy,
  44.             sizx;
  45. };
  46.  
  47. init_time_request(struct timerequest *my_time_request_clock, ULONG my_time_mask_clock)
  48. {
  49.     ULONG interval;
  50.     my_time_request_clock -> tr_node.io_Command     = TR_GETSYSTIME;
  51.     DoIO(my_time_request_clock);
  52.     interval=my_time_request_clock -> tr_time.tv_secs;
  53.     my_time_request_clock -> tr_node.io_Command     = TR_ADDREQUEST;
  54.     my_time_request_clock -> tr_time.tv_secs        = interval+1;
  55.     my_time_request_clock -> tr_time.tv_micro       = 0;
  56.     SetSignal(0,my_time_mask_clock);
  57.     SendIO(my_time_request_clock);
  58. }
  59.  
  60. ULONG snapSub(struct tm_sys_set *set, struct tm_data *data)
  61. {
  62.     struct Gadget       *g;
  63.     int                 i;
  64.  
  65.     g=data->win->FirstGadget;
  66.     data->win=(struct Window *)snapBackground(set,data);
  67.     RemoveGList(data->win,data->win->FirstGadget,-1);
  68.     AddGList(data->win,g,0,-1,NULL);
  69.     drawBackground(set,data);
  70.     for(i=0;i<data->num_of_gaug;i++)
  71.     {
  72.         if(data->gdg[i]!=0)
  73.         {
  74.             SetAttrs(data->gdg[i],GA_Width, data->gauge_x_size, NULL);
  75.             RefreshGList(data->gdg[i],data->win,NULL,1);
  76.         }
  77.     }
  78.     return(1L << data->win->UserPort->mp_SigBit);
  79. }
  80.  
  81. setBase(struct tm_data *data)
  82. {
  83.     struct tm_gau_set   *many;
  84.     int                 i;
  85.     ULONG               cur;
  86.     for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
  87.     {
  88.         if(data->gdg[i]!=0)
  89.         {
  90.             GetAttr(GAU_Current,data->gdg[i],&cur);
  91.             SetAttrs(data->gdg[i],GAU_Current,cur,GAU_Base,cur,TAG_DONE);
  92.             RefreshGList(data->gdg[i],data->win,NULL,1);
  93.         }
  94.     }
  95. }
  96.  
  97. struct tm_sys_set *handler(struct tm_sys_set *set, struct tm_data *data, struct MsgPort *broker_mp, CxObj *broker, ULONG cxsigflag, Class *gclass)
  98. {
  99.     BOOL                        running = TRUE;
  100.  
  101.     ULONG                       interval,
  102.                                 mem_val=0,
  103.                                 vol_val=0,
  104.                                 sigs,
  105.                                 window_mask,
  106.                                 my_time_mask_clock,
  107.                                 my_test_port_mask,
  108.                                 my_noti_port_mask=0L,
  109.                                 my_handler;
  110.  
  111.     struct MsgPort             *my_time_port_clock,
  112.                                *my_test_port,
  113.                                *my_noti_port;
  114.  
  115.     struct timerequest         *my_time_request_clock;
  116.  
  117.     struct NotifyRequest       *notifyrequest;
  118.     LONG                        not_sig;
  119.  
  120.     struct IntuiMessage        *m;
  121.     struct Gadget              *g;
  122.     int                         i;
  123.     ULONG                       cur;
  124.     ULONG                       bas;
  125.     struct TestMessage         *test_msg;
  126.     struct tm_gau_set          *many,*next;
  127.     UBYTE                      *my_file;
  128.     BOOL                        first_run=TRUE;
  129.     UWORD                       do_what;
  130.  
  131.     if(data->scrnot)
  132.     {
  133.         my_noti_port        = (struct MsgPort *)CreateMsgPort();
  134.         my_handler          = ((!data->on_public)|(!strcmp(&set->pub_name[0],"Workbench"))) ? (ULONG)AddWorkbenchClient(my_noti_port,0) : (ULONG)AddCloseScreenClient(data->scr,my_noti_port,0);
  135.         my_noti_port_mask   = 1L << my_noti_port->mp_SigBit;
  136.     }
  137.  
  138.     window_mask  = 1L << data->win->UserPort->mp_SigBit;
  139.  
  140.     if(my_test_port=(struct MsgPort *)CreatePort("TinyMeter",0))
  141.     {
  142.         my_test_port_mask = 1L << (my_test_port->mp_SigBit);
  143.         if(my_time_port_clock=(struct MsgPort *)CreateMsgPort())
  144.         {
  145.             my_time_mask_clock    = 1L << (my_time_port_clock->mp_SigBit);
  146.             if(my_time_request_clock = (struct timerequest *)CreateIORequest(my_time_port_clock,sizeof(struct timerequest)))
  147.             {
  148.                 if(!OpenDevice("timer.device",UNIT_WAITUNTIL,my_time_request_clock,NULL))
  149.                 {
  150.                     if(notifyrequest = (struct NotifyRequest *)AllocVec(sizeof(struct NotifyRequest), MEMF_CLEAR))
  151.                     {
  152.                         if ((not_sig = AllocSignal(-1L)) != -1)
  153.                         {
  154.                             notifyrequest->nr_Name = "ENV:sys/WBPattern.prefs";
  155.                             notifyrequest->nr_Flags = NRF_SEND_SIGNAL;
  156.                             notifyrequest->nr_stuff.nr_Signal.nr_Task = (struct Task *) FindTask(NULL);
  157.                             notifyrequest->nr_stuff.nr_Signal.nr_SignalNum = not_sig;
  158.  
  159.                             if ((StartNotify(notifyrequest)) == DOSTRUE)
  160.                             {
  161.                                 init_time_request(my_time_request_clock,my_time_mask_clock);
  162.  
  163.                                 while(running)
  164.                                 {
  165.                                     if (running) sigs = Wait( my_noti_port_mask | my_test_port_mask | window_mask | my_time_mask_clock | (1L << not_sig) | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | cxsigflag );
  166.  
  167.                                     if (sigs & my_time_mask_clock)
  168.                                     {
  169.                                         if(data->win)
  170.                                         {
  171.                                             do_what=do_clock;
  172.                                             mem_val++;
  173.                                             if(mem_val>=set->mem_refresh)
  174.                                             {
  175.                                                 mem_val=0;
  176.                                                 do_what=do_mem;
  177.                                             }
  178.                                             vol_val++;
  179.                                             if(vol_val>=set->vol_refresh)
  180.                                             {
  181.                                                 vol_val=0;
  182.                                                 do_what=do_vol;
  183.                                             }
  184.  
  185.                                             for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
  186.                                             {
  187.                                                 if(data->gdg[i]!=0)
  188.                                                 switch (do_what)
  189.                                                 {
  190.                                                     case    do_vol:
  191.                                                             if(many->type==typ_volume)
  192.                                                             {
  193.                                                                 getVolsize(set,data,&many->expansion[0]);
  194.                                                                 SetAttrs(data->gdg[i],GAU_Max,data->volmax,GAU_Current,data->volcur,TAG_DONE);
  195.                                                                 BeginRefresh(data->win);
  196.                                                                 EndRefresh(data->win,TRUE);
  197.                                                                 RefreshGList(data->gdg[i], data->win,NULL,1);
  198.                                                             }
  199.                                                     case    do_mem:
  200.                                                             switch (many->type)
  201.                                                             {
  202.                                                                 case    typ_all:
  203.                                                                         cur=AvailMem(0L);
  204.                                                                         break;
  205.                                                                 case    typ_chip:
  206.                                                                         cur=AvailMem(MEMF_CHIP);
  207.                                                                         break;
  208.                                                                 case    typ_fast:
  209.                                                                         cur=AvailMem(MEMF_FAST);
  210.                                                                         break;
  211.                                                                 case    typ_idle:
  212.                                                                         GetAttr(GAU_Current,data->gdg[i],&bas);
  213.                                                                         switch (data->executive)
  214.                                                                         {
  215.                                                                             case    idle_none:
  216.                                                                                     cur=0L;
  217.                                                                                     break;
  218.                                                                             case    idle_executive:
  219.                                                                                     GetCpuUsage(data->si,&data->cpu);
  220.                                                                                     cur=(data->cpu.used_cputime_lastsec_hz-data->cpu.used_cputime_lastsec)<<8;
  221.                                                                                     break;
  222.                                                                             case    idle_own:
  223.                                                                                     cur=idle;
  224.                                                                                     break;
  225.                                                                         }
  226.                                                                         if(bas<cur)SetAttrs(data->gdg[i],GAU_Base,cur,TAG_DONE);
  227.                                                                         break;
  228.                                                                 case    typ_largest_total:
  229.                                                                         cur=AvailMem(MEMF_LARGEST);
  230.                                                                         break;
  231.                                                                 case    typ_largest_chip:
  232.                                                                         cur=AvailMem(MEMF_LARGEST|MEMF_CHIP);
  233.                                                                         break;
  234.                                                                 case    typ_largest_fast:
  235.                                                                         cur=AvailMem(MEMF_LARGEST|MEMF_FAST);
  236.                                                                         break;
  237.                                                                 case    typ_largest_retina:
  238.                                                                         cur=Retina_AvailMem(MEMF_LARGEST);
  239.                                                                         break;
  240.                                                                 case    typ_retina:
  241.                                                                         if(RetinaBase)
  242.                                                                             cur=Retina_AvailMem(0L);
  243.                                                                         else
  244.                                                                             cur=1024L;
  245.                                                                         break;
  246.                                                                 default:
  247.                                                                         goto none_4;
  248.                                                                         break;
  249.                                                             }
  250.                                                             if(do_what!=do_vol)
  251.                                                             {
  252.                                                                 SetAttrs(data->gdg[i],GAU_Current,cur,TAG_DONE);
  253.                                                                 BeginRefresh(data->win);
  254.                                                                 EndRefresh(data->win,TRUE);
  255.                                                                 RefreshGList(data->gdg[i],data->win,NULL,1);
  256.                                                             }
  257.                                                             none_4:
  258.                                                     case    do_clock:
  259.                                                             if(many->type==typ_clock_)
  260.                                                             {
  261.                                                                 SetAttrs(data->gdg[i],GAU_Current,cur,TAG_DONE);
  262.                                                                 BeginRefresh(data->win);
  263.                                                                 EndRefresh(data->win,TRUE);
  264.                                                                 RefreshGList(data->gdg[i],data->win,NULL,1);
  265.                                                             }
  266.                                                             break;
  267.                                                 }
  268.                                             }
  269.                                             if(first_run){setBase(data);first_run=FALSE;}
  270.                                         }
  271.                                         if(set->win_backfront==win_front)
  272.                                         {
  273.                                             if(data->win->WLayer!=data->scr->LayerInfo.top_layer)
  274.                                                 WindowToFront(data->win);
  275.                                         }
  276.                                         init_time_request(my_time_request_clock,my_time_mask_clock);
  277.                                     }
  278.  
  279.                                     if (sigs & window_mask )
  280.                                     {
  281.                                         while(m=(struct IntuiMessage *)GetMsg( data->win->UserPort ))
  282.                                         {
  283.                                             switch ( m->Class )
  284.                                             {
  285.                                                 case    IDCMP_CHANGEWINDOW:
  286.                                                         if(set->bg_type==bg_snap)
  287.                                                         {
  288.                                                             ReplyMsg( m ); while((m=(struct IntuiMessage *)GetMsg( data->win->UserPort )))ReplyMsg( m );
  289.                                                             window_mask=snapSub(set,data);
  290.                                                         }
  291.                                                         else ReplyMsg( m );
  292.                                                         break;
  293.                                                 case    IDCMP_CLOSEWINDOW:
  294.                                                         running=FALSE;
  295.                                                         ReplyMsg( m );
  296.                                                         break;
  297.                                                 case    IDCMP_NEWSIZE:
  298.                                                         {
  299.                                                             new_window_size(set,data);
  300.                                                             set->x_siz=data->win->Width;
  301.                                                             data->gauge_x_size=(set->x_siz-(set->win_border_x<<1)-((set->colums-1)*set->win_space_x))/set->colums;
  302.                                                             switch (set->bg_type)
  303.                                                             {
  304.                                                                 case    bg_file:
  305.                                                                         fileBackground(set,data);
  306.                                                                         break;
  307.                                                                 case    bg_snap:
  308.                                                                         ReplyMsg( m ); while((m=(struct IntuiMessage *)GetMsg( data->win->UserPort )))ReplyMsg( m );
  309.                                                                         g=data->win->FirstGadget;
  310.                                                                         data->win=(struct Window *)snapBackground(set,data);
  311.                                                                         RemoveGList(data->win,data->win->FirstGadget,-1);
  312.                                                                         AddGList(data->win,g,0,-1,NULL);
  313.                                                                         window_mask  = 1L << data->win->UserPort->mp_SigBit;
  314.                                                                         break;
  315.                                                                 default:
  316.                                                                         break;
  317.                                                             }
  318.                                                             drawBackground(set,data);
  319.                                                             for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
  320.                                                             {
  321.                                                                 if(data->gdg[i]!=0)
  322.                                                                 {
  323.                                                                     SetAttrs(data->gdg[i],
  324.                                                                              GA_Left,        set->win_border_x+((i)%set->colums)*data->gauge_x_size+((i)%set->colums)*set->win_space_x,
  325.                                                                              GA_Width,       data->gauge_x_size,
  326.                                                                              TAG_DONE);
  327.                                                                     RefreshGList(data->gdg[i], data->win,NULL,1);
  328.                                                                 }                                                                
  329.                                                             }
  330.                                                         }
  331.                                                         if(set->bg_type!=bg_snap)ReplyMsg( m );
  332.                                                         break;
  333.                                                 case    IDCMP_VANILLAKEY:
  334.                                                         switch(m->Code)
  335.                                                         {
  336.                                                             case    'S':
  337.                                                             case    's':
  338.                                                                     {
  339.                                                                         set->x_pos=data->win->LeftEdge;
  340.                                                                         set->y_pos=data->win->TopEdge;
  341.                                                                         set->x_siz=data->win->Width;
  342.                                                                         if(my_file=(UBYTE *)Open("ENV:TinyMeter",MODE_NEWFILE))
  343.                                                                         {
  344.                                                                             Write(my_file,set,(ULONG) sizeof(struct tm_sys_set));
  345.                                                                             many=data->list;
  346.                                                                             for(i=0;i<data->num_of_gaug;i++)
  347.                                                                             {
  348.                                                                                 Write(my_file,many,(ULONG) sizeof(struct tm_gau_set));
  349.                                                                                 many=many->next;
  350.                                                                             }
  351.                                                                             Close(my_file);
  352.                                                                         }
  353.                                                                         if(my_file=(UBYTE *)Open("ENVARC:TinyMeter",MODE_NEWFILE))
  354.                                                                         {
  355.                                                                             Write(my_file,set,(ULONG) sizeof(struct tm_sys_set));
  356.                                                                             many=data->list;
  357.                                                                             for(i=0;i<data->num_of_gaug;i++)
  358.                                                                             {
  359.                                                                                 Write(my_file,many,(ULONG) sizeof(struct tm_gau_set));
  360.                                                                                 many=many->next;
  361.                                                                             }
  362.                                                                             Close(my_file);
  363.                                                                         }
  364.                                                                     }
  365.                                                                     ReplyMsg( m );
  366.                                                                     break;
  367.                                                             case    'F':
  368.                                                             case    'f':
  369.                                                                     {
  370.                                                                         ULONG   my_mem;
  371.                                                                         Forbid();
  372.                                                                         my_mem= AllocVec(2000000000L,MEMF_PUBLIC);
  373.                                                                         if(my_mem)FreeVec(my_mem);
  374.                                                                         Permit();
  375.                                                                     }
  376.                                                                     ReplyMsg( m );
  377.                                                                     break;
  378.                                                             case    'Q':
  379.                                                             case    'q':
  380.                                                                     running=FALSE;
  381.                                                                     ReplyMsg( m );
  382.                                                                     break;
  383.                                                             case    'b':
  384.                                                             case    'B':
  385.                                                                     if(set->bg_type==bg_snap)
  386.                                                                     {
  387.                                                                         ReplyMsg( m ); while((m=(struct IntuiMessage *)GetMsg( data->win->UserPort )))ReplyMsg( m );
  388.                                                                         window_mask=snapSub(set,data);
  389.                                                                     }
  390.                                                                     else ReplyMsg( m );
  391.                                                                     break;
  392.                                                         }
  393.                                                         break;
  394.                                                 case    IDCMP_MOUSEBUTTONS:
  395.                                                         if((m->Code&129)==1)
  396.                                                         {
  397.                                                             setBase(data);
  398.                                                         }
  399.                                                         ReplyMsg( m );
  400.                                                         break;
  401.                                                 default :
  402.                                                         ReplyMsg( m );
  403.                                                         break;
  404.                                             }
  405.                                         }
  406.                                     }
  407.  
  408.                                     if (sigs & (1L << not_sig))
  409.                                     {
  410.                                         Delay(100L);
  411.                                         switch (set->bg_type)
  412.                                         {
  413.                                             case    bg_snap:
  414.                                                     window_mask=snapSub(set,data);
  415.                                                     break;
  416.                                             default:
  417.                                                     break;
  418.                                         }
  419.                                     }
  420.  
  421.                                     if (sigs & cxsigflag)
  422.                                     {
  423.                                         CxMsg *msg;
  424.                                         ULONG sigrcvd, msgid, msgtype;
  425.  
  426.                                         while(msg = (CxMsg *)GetMsg(broker_mp))
  427.                                         {
  428.                                             msgid = CxMsgID(msg);
  429.                                             msgtype = CxMsgType(msg);
  430.                                             if(msgtype==CXM_COMMAND)
  431.                                             switch(msgid)
  432.                                             {
  433.                                                 case    CXCMD_DISABLE:
  434.                                                         {
  435.                                                             BOOL pause=TRUE;
  436.                                                             ActivateCxObj(broker, 0L);
  437.                                                             while(pause)
  438.                                                             {
  439.                                                                 Wait(cxsigflag);
  440.                                                                 while(msg = (CxMsg *)GetMsg(broker_mp))
  441.                                                                 {
  442.                                                                     msgid = CxMsgID(msg);
  443.                                                                     msgtype = CxMsgType(msg);
  444.                                                                     ReplyMsg((struct Message *)msg);
  445.                                                                     if(msgtype==CXM_COMMAND) if(msgid==CXCMD_ENABLE) pause=FALSE;
  446.                                                                 }
  447.                                                             }
  448.                                                             ActivateCxObj(broker, 1L);
  449.                                                         }
  450.                                                         break;
  451.                                                 case    CXCMD_ENABLE:
  452.                                                         ActivateCxObj(broker, 1L);
  453.                                                         break;
  454.                                                 case    CXCMD_KILL:
  455.                                                         running=FALSE;
  456.                                                         break;
  457.                                             }
  458.                                             ReplyMsg((struct Message *)msg);
  459.                                         }
  460.                                     }
  461.  
  462.                                     if ((sigs & my_test_port_mask))
  463.                                     {
  464.                                         while(test_msg=(struct TestMessage *)GetMsg(my_test_port))
  465.                                         {
  466.                                             switch (test_msg->MethodID)
  467.                                             {
  468.                                                 case    test_test:
  469.                                                         closeWindow(set,data);
  470.                                                         removeGadgets(set,data);
  471.                                                         first_run=TRUE;
  472.                                                         if(test_msg->set && test_msg->list) /* To be sure that no trash arrives here */
  473.                                                         {
  474.                                                             /* Free old settings */
  475.                                                             FreeVec(set);
  476.                                                             many=data->list;
  477.                                                             do
  478.                                                             {
  479.                                                                 next=many->next;
  480.                                                                 FreeVec(many);
  481.                                                             }
  482.                                                             while(many=next);
  483.                                                             /* get new settings */
  484.                                                             set                 = test_msg->set;
  485.                                                             data->list          = test_msg->list;
  486.                                                             data->num_of_gaug   = getNum(data->list);
  487.                                                         }
  488.                                                         /* initialize new settings */
  489.                                                         if(openWindow(set,data))
  490.                                                         {
  491.                                                             drawBackground(set,data);
  492.                                                             allocGadgets(set,data,gclass);
  493.                                                             window_mask  = 1L << data->win->UserPort->mp_SigBit;
  494.                                                         }
  495.                                                         else running=FALSE;
  496.                                                         setBase(data);
  497.                                                         break;
  498.                                                 case    test_getwin:
  499.                                                         test_msg->posx=data->win->LeftEdge;
  500.                                                         test_msg->posy=data->win->TopEdge;
  501.                                                         test_msg->sizx=data->win->Width;
  502.                                                         break;
  503.                                             }
  504.                                             ReplyMsg(test_msg);
  505.                                         }
  506.                                     }
  507.  
  508.                                     if(data->scrnot)
  509.                                     {
  510.                                         if (sigs & my_noti_port_mask)
  511.                                         {
  512.                                             struct ScreenNotifyMessage  *snm;
  513.                                             while(snm = (struct ScreenNotifyMessage *) GetMsg(my_noti_port))
  514.                                             {
  515.                                                 switch(snm->snm_Type)
  516.                                                 {
  517.                                                     case    SCREENNOTIFY_TYPE_CLOSESCREEN:
  518.                                                             running=FALSE;
  519.                                                             break;
  520.                                                     case    SCREENNOTIFY_TYPE_WORKBENCH:
  521.                                                             switch ((ULONG)snm->snm_Value)
  522.                                                             {
  523.                                                                 case    FALSE:
  524.                                                                         closeWindow(set,data);
  525.                                                                         removeGadgets(set,data);
  526.                                                                         ReplyMsg((struct Message *) snm);
  527.                                                                         Wait(my_noti_port_mask);
  528.                                                                         while(snm = (struct ScreenNotifyMessage *) GetMsg(my_noti_port))
  529.                                                                         {
  530.                                                                             if(snm->snm_Type==SCREENNOTIFY_TYPE_WORKBENCH)
  531.                                                                             {
  532.                                                                                 if((ULONG)snm->snm_Value==TRUE)
  533.                                                                                 {
  534.                                                                                     ReplyMsg((struct Message *) snm);
  535.                                                                                     Delay(50L);
  536.                                                                                     if(openWindow(set,data))
  537.                                                                                     {
  538.                                                                                         drawBackground(set,data);
  539.                                                                                         allocGadgets(set,data,gclass);
  540.                                                                                         window_mask  = 1L << data->win->UserPort->mp_SigBit;
  541.                                                                                     }
  542.                                                                                     else running=FALSE;
  543.                                                                                     setBase(data);
  544.                                                                                 }
  545.                                                                                 else running=FALSE;
  546.                                                                             }
  547.                                                                             else running=FALSE;
  548.                                                                         }
  549.                                                                         first_run=TRUE;
  550.                                                                         window_mask = 0L;
  551.                                                                         break;
  552.                                                             }
  553.                                                             break;
  554.                                                 }
  555.                                             }
  556.                                         }
  557.                                         Delay(10L);
  558.                                     }
  559.  
  560.                                     if (sigs & (SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D)) running=FALSE;
  561.                                 }
  562.                             }
  563.                             else show("StartNotify failed!");
  564.                             FreeSignal(not_sig);
  565.                         }
  566.                         else show("Could not allocate signal!");
  567.                         FreeVec(notifyrequest);
  568.                     }
  569.                     else show("Not enough memory!");
  570.                     if(!CheckIO(my_time_request_clock))
  571.                         AbortIO(my_time_request_clock);
  572.                     WaitIO(my_time_request_clock);
  573.                     CloseDevice(my_time_request_clock);
  574.                 }
  575.                 else show("timer.device usage failed!");
  576.                 DeleteIORequest(my_time_request_clock);
  577.             }
  578.             else show("CreateIORequest failed!");
  579.             DeleteMsgPort(my_time_port_clock);
  580.         }
  581.         else show("CreateMsgPort failed!");
  582.         DeletePort(my_test_port);
  583.     }
  584.     else show("CreatePort failed.!");
  585.  
  586.     if(data->scrnot)
  587.     {
  588.         if((!data->on_public)|(!strcmp(&set->pub_name[0],"Workbench")))
  589.             while(!RemWorkbenchClient(my_handler)) Delay(10);
  590.         else
  591.             while(!RemCloseScreenClient(my_handler)) Delay(10);
  592.         DeleteMsgPort(my_noti_port);
  593.     }
  594.  
  595.     return(set);
  596. }
  597.  
  598.